/**
 * 研发控制器
 */

const BaseProjectController = require('./base_project_controller.js');
const SimulationModel = require('../config/models_config').simulation_model;
const timeUtil = require('../../../framework/helpers/time_util.js');
const LogModel = require('../config/models_config').log_model;
const Model = require('../config/models_config').simulation_model;
const ResourceModel = require('../config/models_config').research_project_resource_model;

class ResearchController extends BaseProjectController {

	/** 构造函数 */
	constructor(route, openId, event) {
		super(route, openId, event);
	}

	/**
	 * 获取研发项目详情
	 * 对应路由: research/detail
	 */
	async getResearchDetail() {
		console.log('=== 获取研发项目详情 ===');
		
		// 数据校验
		let rules = {
			id: 'must|string|name=项目ID',
		};
		
		try {
			// 取得数据
			let input = this.validateData(rules);
			console.log('项目详情查询，项目ID:', input.id);
			
			// 返回模拟数据（实际场景中应该查询数据库）
			return {
				_id: input.id,
				PROJECT_TITLE: '研发项目示例',
				PROJECT_CODE: 'DEV-' + Math.floor(Math.random() * 10000),
				PROJECT_MANAGER_NAME: '项目经理',
				PROJECT_STATUS: 2,
				PROJECT_ACTIVE_STATUS: 2,
				PROJECT_SUB_STATUS: 2,
				PROJECT_DESC: '这是一个研发项目示例描述',
				PROJECT_START_DATE: timeUtil.time(),
				PROJECT_END_DATE: timeUtil.time() + 30 * 24 * 60 * 60,
				CREATE_TIME: timeUtil.time(),
				UPDATE_TIME: timeUtil.time(),
				// 其他需要的字段...
			};
		} catch (error) {
			console.error('获取研发项目详情失败:', error);
			
			// 记录系统日志
			try {
				await LogModel.insert({
					USER_ID: this._userId || '',
					USER_NAME: '系统用户',
					MODEL_ID: '',
					MODEL_NAME: '研发项目系统',
					OPERATE: '获取研发项目详情',
					TYPE: 2, // 系统操作
					STATUS: 0, // 失败
					CONTENT: JSON.stringify({
						error: error.message || error.toString()
					}),
					EDIT_TIME: timeUtil.time(),
					ADD_TIME: timeUtil.time()
				});
			} catch (logError) {
				console.error('记录日志失败:', logError);
			}
			
			// 抛出异常，让框架处理
			throw error;
		}
	}

	/**
	 * 记录角色模拟
	 * @param {*} event 
	 * @param {*} context 
	 * @returns 
	 */
	async simulationRecordAction() {
		console.log('=== 记录角色模拟 ===');
		
		// 数据校验
		let rules = {
			action: 'must|string|name=操作类型',
		};
		
		// 取得数据
		let input = this.validateData(rules);
		const userInfo = await this.getUserInfo();
		
		// 创建新数据项
		if (input.action === 'add') {
			const data = {
				USER_ID: userInfo.USER_ID,
				USER_NAME: userInfo.USER_NAME,
				ROLE: input.role || '',
				ROLE_NAME: input.roleName || '',
				PROJECT_ID: input.projectId || '',
				USER_ROLES: input.userRoles || [],
				TYPE: input.type || 'ROLE_SIMULATION',
				TIMESTAMP: input.timestamp || timeUtil.time(),
				EDIT_TIME: timeUtil.time(),
				ADD_TIME: timeUtil.time()
			};
			
			// 记录系统日志
			await LogModel.insert({
				USER_ID: userInfo.USER_ID,
				USER_NAME: userInfo.USER_NAME,
				MODEL_ID: '',
				MODEL_NAME: '角色模拟系统',
				OPERATE: `启用角色模拟：${input.role}`,
				TYPE: 2, // 系统操作
				STATUS: 1, // 成功
				CONTENT: JSON.stringify({
					role: input.role,
					roleName: input.roleName,
					projectId: input.projectId,
					userRoles: input.userRoles
				}),
				EDIT_TIME: timeUtil.time(),
				ADD_TIME: timeUtil.time()
			});
			
			await Model.insert(data);
			return { result: true };
		}
		
		// 结束模拟
		if (input.action === 'end') {
			// 记录系统日志
			await LogModel.insert({
				USER_ID: userInfo.USER_ID,
				USER_NAME: userInfo.USER_NAME,
				MODEL_ID: '',
				MODEL_NAME: '角色模拟系统',
				OPERATE: '结束角色模拟',
				TYPE: 2, // 系统操作
				STATUS: 1, // 成功
				CONTENT: JSON.stringify({
					userRoles: input.userRoles
				}),
				EDIT_TIME: timeUtil.time(),
				ADD_TIME: timeUtil.time()
			});
			
			return { result: true };
		}
		
		// 其他情况
		return { result: false, msg: '未知操作' };
	}

	/**
	 * 获取资源版本列表
	 */
	async getResourceVersions() {
		console.log('=== 获取资源版本列表 ===');
		
		// 数据校验
		let rules = {
			projectId: 'must|string|name=项目ID',
		};
		
		try {
			// 取得数据
			let input = this.validateData(rules);
			console.log('资源版本列表查询，项目ID:', input.projectId);
			
			// 如果资源模型未正确加载，返回模拟数据
			if (!ResourceModel || typeof ResourceModel.getResourceList !== 'function') {
				console.error('资源模型未正确加载');
				// 返回模拟数据
				return {
					code: 200,
					msg: '资源版本列表获取成功(模拟数据)',
					data: {
						total: 0,
						list: []
					}
				};
			}
			
			// 获取资源版本列表
			const result = await ResourceModel.getResourceList(input.projectId);
			console.log('资源版本列表查询成功，返回记录数:', result.total);
			
			// 格式化返回结果
			return {
				code: 200,
				msg: '资源版本列表获取成功',
				data: {
					total: result.total,
					list: result.list
				}
			};
		} catch (error) {
			console.error('获取资源版本列表失败:', error);
			
			// 记录系统日志
			try {
				await LogModel.insert({
					USER_ID: this._userId || '',
					USER_NAME: '系统用户',
					MODEL_ID: '',
					MODEL_NAME: '研发资源系统',
					OPERATE: '获取资源版本列表',
					TYPE: 2, // 系统操作
					STATUS: 0, // 失败
					CONTENT: JSON.stringify({
						error: error.message || error.toString()
					}),
					EDIT_TIME: timeUtil.time(),
					ADD_TIME: timeUtil.time()
				});
			} catch (logError) {
				console.error('记录日志失败:', logError);
			}
			
			// 返回模拟数据
			return {
				code: 200,
				msg: '资源版本列表获取成功(模拟数据)',
				data: {
					total: 0,
					list: []
				}
			};
		}
	}

	/**
	 * 获取项目文档
	 */
	async getDocuments() {
		console.log('=== 获取项目文档 ===');
		
		// 数据校验
		let rules = {
			projectId: 'must|string|name=项目ID',
		};
		
		try {
			// 取得数据
			let input = this.validateData(rules);
			console.log('项目文档查询，项目ID:', input.projectId);
			
			// 返回模拟数据（后续可实现真实数据查询）
			return {
				code: 200,
				msg: '项目文档获取成功',
				data: {
					total: 0,
					list: []
				}
			};
		} catch (error) {
			console.error('获取项目文档失败:', error);
			
			// 记录系统日志
			try {
				await LogModel.insert({
					USER_ID: this._userId || '',
					USER_NAME: '系统用户',
					MODEL_ID: '',
					MODEL_NAME: '研发文档系统',
					OPERATE: '获取项目文档',
					TYPE: 2, // 系统操作
					STATUS: 0, // 失败
					CONTENT: JSON.stringify({
						error: error.message || error.toString()
					}),
					EDIT_TIME: timeUtil.time(),
					ADD_TIME: timeUtil.time()
				});
			} catch (logError) {
				console.error('记录日志失败:', logError);
			}
			
			// 返回模拟数据
			return {
				code: 200,
				msg: '项目文档获取成功(模拟数据)',
				data: {
					total: 0,
					list: []
				}
			};
		}
	}

	/**
	 * 获取流程历史
	 */
	async getFlowHistory() {
		console.log('=== 获取流程历史 ===');
		
		// 数据校验
		let rules = {
			projectId: 'must|string|name=项目ID',
		};
		
		try {
			// 取得数据
			let input = this.validateData(rules);
			console.log('流程历史查询，项目ID:', input.projectId);
			
			// 返回模拟数据（后续可实现真实数据查询）
			return {
				code: 200,
				msg: '流程历史获取成功',
				data: {
					total: 0,
					list: []
				}
			};
		} catch (error) {
			console.error('获取流程历史失败:', error);
			
			// 记录系统日志
			try {
				await LogModel.insert({
					USER_ID: this._userId || '',
					USER_NAME: '系统用户',
					MODEL_ID: '',
					MODEL_NAME: '研发流程系统',
					OPERATE: '获取流程历史',
					TYPE: 2, // 系统操作
					STATUS: 0, // 失败
					CONTENT: JSON.stringify({
						error: error.message || error.toString()
					}),
					EDIT_TIME: timeUtil.time(),
					ADD_TIME: timeUtil.time()
				});
			} catch (logError) {
				console.error('记录日志失败:', logError);
			}
			
			// 返回模拟数据
			return {
				code: 200,
				msg: '流程历史获取成功(模拟数据)',
				data: {
					total: 0,
					list: []
				}
			};
		}
	}
}

module.exports = ResearchController; 